Systems and methods for providing signatureless, confidential and authentication of data during handshake for classical and quantum computing environments

ABSTRACT

Systems and methods for handshaking, without a certificate authority, to provide at least post-quantum communications security over a computer network. The method generates an authentication tag, hashing, by an initiator, a concatenation of unique identifiers of the initiator and a recipient. The method also generates an encrypted text, symmetrically encrypting, by the initiator that is configured to use a shared secret, a concatenation of the authentication tag and the unique identifiers of the initiator and the recipient. The method further includes sending the encrypted text from the initiator to a server. The method also includes symmetrically decrypting, by the server that is configured to use the shared secret, the encrypted text. The method further includes authenticating, by the server, the encrypted text. The method also includes generating a session key and providing the session key from the server to the initiator.

The applicant claims the benefit under 35 USC 119(e) of U.S. Provisional Application No. 63/180,504 filed on Apr. 27, 2021, and U.S. Provisional Application No. 63/153,382 filed on Feb. 25, 2021, which is incorporated herein by reference in its entirety.

FIELD OF THE INVENTION

The present disclosure relates to system providing a quantum channel security protocol.

BACKGROUND

Transport Layer Security (TLS) is a widely deployed protocol over IP networks for providing a non-quantum secure channel between two communicating hosts, typically a client and a server. In fact, Transport Layer Security (TLS) allows client/server-based applications (such as Web browsing, electronic mail, Voice-over-IP, video-phoning, video-conferencing, Internet faxing, or instant messaging) to communicate, while preventing eavesdropping and message forgery and tampering.

TLS includes a handshake protocol for authentication and security parameters negotiation between two communicating entities, and a record protocol for data transfer between these two communicating entities using the parameters agreed via the handshake protocol.

For establishing a Transport Layer Security (TLS) session, the handshake protocol—as defined in RFC2246—allows peers to agree upon security parameters for the record layer (such as the encryption algorithm and the encryption keys), to authenticate themselves, to instantiate negotiated security parameters and to report error conditions to each other. these tasks are performed through a series of handshake messages exchange in a specific order between a client and a server.

The client sends a “Client Hello” message to the server; the server responds with a “Server Hello” message. In the two hello messages, the client and the server agree on security parameters and authenticate themselves: the server sends its certificate to the client. If needed, it sends also a certificate request in the same message. It might also send a “server key exchange” message if the certificate is not sufficient. in response, the client sends a “client key exchange” message and its certificate to the server along with a “certificate verify” message so that the server explicitly verify this certificate; both, the client and the server send “change cipher spec” messages and proceed directly to finished messages. Subsequently, the client and the server may begin to send and receive application data using the negotiated session parameters.

It follows that the handshake protocol checks the identity of the client after exchanging the certificates for authentication.

However, such approach for client identity verification by the server may represent a serious problem for many reasons.

In fact, for instance, in a wide communication network such as Internet, a server providing a certain service (including business transactions) is particularly subject to strange clients with no prior relationship and no common security domain with them. In this case, the server does check the identity of clients only by the end (i.e. at the conclusion) of the handshaking.

Furthermore, a server may be interested to serve only particular clients (for example, being in a predefined list or being located in a given state). Nevertheless, according to the existing TLS handshake protocol, this server is constrained to carry out more than one step of the handshake protocol to check the identity of clients, and to be able to decide on the continuation of the interaction.

Yet another problem is that the server's behavior regarding certificates exchange and cipher negotiation during TLS handshake is the same, without any relevance to the identity of the clients. Accordingly, there is no way for a server to know which client is triggering a TLS handshake before the handshake is actually finished.

There have various efforts towards developing a quantum-secure version of TLS. Initial efforts analyze the effect of replacing the vulnerable algorithms with post quantum variants. However, these studies show that the large public key sizes and computationally intensive processes of these methods slow down the handshake time considerably. This motivates the design of the disclosed system and methods which have overcome these issues.

Authentication/Identity is another issue within modern computer systems that provide service to multiple users and require the ability to accurately identify the user making a request. In traditional systems, the user's identity is verified by checking a password typed during login; the system records the identity and uses it to determine what operations may be performed. The process of verifying the user's identity is called authentication. Password based authentication is not suitable for use on computer networks. Passwords sent across the network can be intercepted and subsequently used by eavesdroppers to impersonate the user. While this vulnerability has been long known, it has been demonstrated on a major scale with the discovery of planted password collecting programs at critical points on the Internet.

Another object of the present disclosed system and methods is to eliminate the issues of Authentication, Integrity, Confidentiality, and Authorization. The disclosed system and methods has provided this solution with a proprietary Authorization mechanism as well as a standards-based Kerberos framework which allows this objective to be realized in a quantum secure environment and use the advanced quantum encryption available with this disclosed system and methods or can be used while associating with non-quantum based standard Kerberos systems.

Another object of the present disclosed system and methods is to eliminate unnecessary steps in the negotiation during the security handshake protocol.

Another object of the present disclosed system and methods is to customize the client/server behavior regarding the elimination of the need for certificates exchange and a trusted Root Authority (CA) that generates self-signed public key use this to distribute signed public/private key pairs down the certificate chain to sub-CAs.

Another object is to create a zero trust and cipher negotiation during Quantum Secure Layer QSL handshake.

Another object of the present disclosed system and methods is to provide a post-quantum secure and backward channel security protocol.

SUMMARY OF THE INVENTION

Various embodiments are directed to addressing the effects of at least one of the problems set forth above. The following presents a simplified summary of embodiments in order to provide a basic understanding of some aspects of the various embodiments. This summary is not an exhaustive overview of these various embodiments. It is not intended to identify key of critical elements or to delineate the scope of these various embodiments. Its sole purpose is to present some concepts in a simplified form as a prelude to the more detailed description that is discussed later.

Confidentiality and authentication are two aspects of data privacy protection. Confidentiality pertains to the treatment of information that an individual or entity has disclosed in a relationship of trust and with the expectation that it will not be divulged to others without permission in ways that are inconsistent with the understanding of the original disclosure.

Authentication is the process or action of verifying the identity of a user, process or data. User authentication for each device ensures that the individual using the device is recognized by the company. Authentication provides assurance that data has not been altered in any way after the data is sent or stored. Handshaking is a process/procedure that establishes secure communications between two parties over a computer network. This process has a standards-based method approach with the incorporation of the Kerberos framework as well as proprietary mechanism to accomplish this base issue.

A digital signature used in current Public Key Infrastructure (PKI) implementations consist of public and private key pair received from a Certificate Authority (CA) which can be used to provide confidentiality and authentication during handshaking. However, this process is only secure when the CA is deemed trustworthy.

A shared secret (e.g., a symmetric key) can also be used to provide confidentiality and authentication during handshaking. Unlike a digital signature which requires a CA to be established, a shared secret can be established without a CA. Further, as described herein, a shared secret can provide post-quantum communications security during handshaking with reduced execution time.

Accordingly, the present disclosure provides systems and methods for providing, among other things, signatureless, confidentiality and authentication of data during handshaking in classical and quantum computing environments.

The present disclosure provides a method for secure handshaking for confidentiality and proper authentication, without a certificate authority, and adding continuous random quantum session security key updates to provide at least post-quantum communications security (i.e., PQCS) over a computer network.

The method comprises, with initial communication the generation of a authentication tag, and hashing within the initiator, concatenation of a unique identifier of the initiator and a unique identifier of a recipient.

The method continues, by generating encrypted text which uses symmetrical encryption, by the initiator that is configured to use a shared secret, concatenation of the unique identifier of the initiator, the unique identifier of the recipient, and the authentication tag.

The method further comprises sending the encrypted text from the initiator to a server.

The method also comprises, to generate the unique identifier of the initiator, the unique identifier of the recipient, and a first instance of the authentication tag, symmetrically decrypting, by the server that is configured to use the shared secret, the encrypted text.

The method further comprises authenticating, by the server, the encrypted text. Authenticating the encrypted text comprises, to generate a second instance of the authentication tag, hashing a concatenation of the unique identifier of the initiator and the unique identifier of the recipient. Authenticating the encrypted text further comprises determining that the second instance of the authentication tag matches the first instance of the authentication tag. The method also comprises, responsive to authenticating the encrypted text, generating, by the server, a quantum session key.

The method further includes providing the quantum session key from the server to the initiator.

The present invention also provides a system for handshaking for confidentiality and proper authentication, without a certificate authority, to provide at least post-quantum communications security over a computer network.

The system comprises, in one implementation, an initiator and a server. The initiator is configured to generate an authentication tag by hashing a concatenation of a unique identifier of the initiator and a unique identifier of a recipient. The initiator is also configured to generate an encrypted text by symmetrically encrypting, using a shared secret, a concatenation of the unique identifier of the initiator, the unique identifier of the recipient, and the authentication tag. The server is configured to receive the encrypted text from the initiator. The server is also configured to generate the unique identifier of the initiator, the unique identifier of the recipient, and a first instance of the authentication tag by symmetrically decrypting, using the shared secret, the encrypted text. The server is further configured to authenticate the encrypted text. Authenticating the encrypted text comprises, to generate a second instance of the authentication tag, hashing a concatenation of the unique identifier of the initiator and the unique identifier of the recipient. Authenticating the encrypted text also comprises determining that the second instance of the authentication tag matches the first instance of the authentication tag. The server is also configured to generate, responsive to authenticating the encrypted text, a session key. The server is further configured to provide the session key to the initiator

The present invention further provides a method for handshaking, without a certificate authority, to provide at least post-quantum communications security over a computer network. The method comprises, to generate an authentication tag, hashing, by an initiator, a combination of at least a unique identifier of the initiator and a unique identifier of a recipient. The method also comprises, to generate an encrypted text, symmetrically encrypting, by the initiator that is configured to use a shared secret, a combination of at least the unique identifier of the initiator, the unique identifier of the recipient, and the authentication tag. The method further comprises sending the encrypted text from the initiator to a server. The method also comprises, to generate the unique identifier of the initiator, the unique identifier of the recipient, and a first instance of the authentication tag, symmetrically decrypting, by the server that is configured to use the shared secret, the encrypted text. The method further comprises authenticating, by the server, the encrypted text. Authenticating the encrypted text comprises, to generate a second instance of the authentication tag, hashing a combination of the unique identifier of the initiator and the unique identifier of the recipient. Authenticating the encrypted text also comprises determining that the second instance of the authentication tag matches the first instance of the authentication tag. The method also comprises, responsive to authenticating the encrypted text, generating, by the server, a first session key. The method further comprises providing the first session key from the server to the initiator. The method also comprises generating, by the server, a second session key. The method further comprises providing the second session key from the server to the initiator. The providing of the second session key from the server to the initiator is performed prior to a predetermined number of data bytes being encrypted by using the first session key.

Other technical features may be apparent to one skilled in the art from the following figures, descriptions, and claims but not captured in this summary.

BRIEF DESCRIPTION OF THE DRAWINGS

For a more complete understanding of the present disclosure and its advantages, reference is now made to the following description, taken in conjunction with the accompanying drawings. It is emphasized that, according to common practice, the various features of the drawings are not necessarily to-scale. On the contrary, the dimensions of the various features may be and typically are—arbitrarily expanded or reduced for the purpose of clarity.

FIG. 1A is a block diagram of an example of a system for handshaking, without a certificate authority, to provide at least post-quantum communications security over a computer network, in accordance with some implementations of the present invention.

FIG. 1B is a block diagram of an example of the components interacting with the Clients 120 a and 120 b, without a certificate authority, to provide at least post-quantum communications security over a computer network, in accordance with some implementations of the present invention.

FIG. 1C is a block diagram of an example structure of a unique identifier dataset, in accordance with some implementations of the present invention.

FIG. 1D is a block diagram of an example structure of a key management service (KMS) dataset, in accordance with some implementations of the present invention.

FIG. 2 is a block diagram of an example of a computer system, in accordance with some implementations of the present invention.

FIG. 3A is a flow diagram of an example method for Authenticated Encryption with Associated Data using the Hash-then-Encrypt method, in accordance with some implementations of the present invention.

FIG. 3B is a flow diagram of an example method for Authenticated Encryption with Associated Data using the Encrypt-then-Hash method, in accordance with some implementations of the present invention.

FIG. 4 is a flow diagram of an example method for exchanging variable length buffers using Authenticated Encryption with Associated Data (AEAD), in accordance with some implementations of the present invention.

FIG. 5A is a flow diagram of an example method for one-to-one quantum security layer (QSL) handshaking, without a certificate authority, to provide at least post-quantum communications security over a computer network, in accordance with some implementations of the present invention.

FIG. 5B is a flow diagram of an example method for one-to-many quantum security layer (QSL) handshaking, without a certificate authority, to provide at least post-quantum communications security over a computer network, in accordance with some implementations of the present invention.

FIG. 6A is a flow diagram of an example method for exchanging a single shared secret via post-quantum Key Encapsulation Mechanism algorithms, in accordance with some implementations of the present invention.

FIG. 6B is a flow diagram of an example method for exchanging multiple shared secrets via post-quantum Key Encapsulation Mechanism algorithms, in accordance with some implementations of the present invention.

FIG. 6C is a flow diagram of an example method providing forward secrecy via post-quantum Key Encapsulation Mechanism algorithms, in accordance with some implementations of the present invention.

FIG. 7 is a flow diagram of an example method providing client registration with the server, in accordance with some implementations of the present disclosure.

FIG. 8 is a flow diagram of an example method for alternating between session keys following a Moving Target design, in accordance with some implementations of the present invention.

FIG. 9 is a flow diagram of an example method for client login to the server after registration has been completed, in accordance with some implementations of the present invention.

DETAILED DESCRIPTION OF ILLUSTRATIVE EMBODIMENTS

With reference to FIGS. 1A and 1B, shown a current preferred embodiment of the invention. Within this illustration the aspects as described within this disclosure show the elimination of unnecessary steps in the negotiation during the security handshake protocol. Customize the client/server behavior regarding the elimination of the need for certificate exchange and a trusted Root Certificate Authority (CA) that generates self-signed public key use this to distribute signed public/private key pairs down the certificate chain to sub-CAs. Additionally, to create a zero trust cipher negotiation during QSL handshake and to provide a post-quantum secure and backward channel security protocol.

With reference to FIGS. 1A and 1B a Server 100, a block diagram of an example of a system for handshaking, and components without a certificate authority, to provide at least post-quantum communications security over a computer network. The server 100 includes a server 100, clients 120 a 120 b, and a communication networks 130, 132, 134. The Server 100 illustrated in FIG. 1A is provided as one example of such a system. The methods described herein may be used with systems with fewer, additional, or different components in different configurations than the Server 100 illustrated in FIG. 1A. For example, in some implementations, the Server 100 may include additional servers, may include additional or fewer clients, and/or may include more communication networks. Although illustrated as separate components in FIG. 1A, in some implementations, the Server 100 and one or more clients 120 a and 120 b may be included in a single electronic device. For example, the Server 100 and the initiator 108 may be included in a single electronic device. As a further example, the Server 100 and the recipient 120 a or 120 b may be included in a single electronic device.

Unique Identifier Database and Key Management Database are configured with a static secret key (using a different Key Encapsulation Mechanism (KEM) keypair than is shared with clients) and Services are configured with the corresponding static public key. At system start, the Forward Secrecy Handshake is performed between the Databases and the Services which access those databases—this is repeated periodically (after a number of bytes has been encrypted, for example) to maintain forward secrecy between Databases and Services during runtime. The Databases offload KEM keygen and decapsulation to the HSM, and the relevant Services offload encapsulation to the HSM.

Unique Identifier Dataset FIG. 1C 101 illustrates the current preferred embodiment of the database scheme used to identify a unique entity for communication from the Quantum Secure Layer Service 110. This communication or Data at Rest encryption process uses this structure to complete the handshake as in Quantum Secure Layer Handshake 110 b for the purpose of encrypting the necessary data and keys between multiple clients 120 a or 120 b.

Key Management Dataset FIG. 1D 102 illustrates the current preferred embodiment of the database scheme used to identify elements within the Key Management Service 113 for communication within the Quantum Secure Layer Service 110. The Key Management Dataset 102 FIG. 1D is used to add symmetric keys when requested from other services using Key Add Service 114 a and to use keys that are in the processes with the Key Get Service 115 a. Because the Key Management Service 114 a resides within the Hardware Security Module logic construct an actual “Handle” is used versus the key for better security retrieval.

Hardware Security Module (HSM) FIG. 1A 108 all KEM and cryptographic operations are controlled though the HSM. This component has all cryptographic algorithms and systems logic to avoid security side channel attacks on key pairs or symmetric keys or not limited to other elements requiring vaulting protection. The Hardware Security Module (HSM) 108 controls but not limited to key creation and extraction from the Quantum Random Number Generator 109 and associated storage.

Quantum Random Number Generator (QRNG) FIG. 1A 109 QRNG delivers random numbers for the generation of cryptographic keys and other security parameters, deterministic RNG seeding, initialization vectors, nonces, random challenges, authentication and DSA signing. Other applications include Entropy as a Service (EaaS), simulations, modeling and computer gaming. This generator feeds the cryptographic keys directly into the Hardware Security Module for greater entropy security retrieval. Other outside processes are shielded from this generator. Only protocols that reside within the HSM can access the n-dimensional quantum key source that is produced.

Quantum Secure Layer Service FIG. 1A 110 This component uses the Quantum Secure Layer Handshake 110 b which is the interaction between key distribution center and client 120 a or 120 b. QSL Service 110 is used by the Clients 120 a and 120 b to create a secure communications session between the two clients. This supplies the necessary symmetric key by reaching out to the Hardware Security Module (HSM) 108. The interaction between the client peers requests a communication with the necessary unique identifier to establish communications for but not limited to file transfer, messaging, hypertext communications. This service will query all information required from the Unique Identifier Dataset 101 to establish communication this includes but limited to symmetric keys. This follows File Transfer 116 and Hypertext Transfer 118 as it interacts with the Quantum Secure Layer Handshake 110 c and 110 d and the Quantum Secure Layer Service 110.

Quantum Secure Layer Handshake FIG. 1A 110 b This handshake is used to interact with any application with the examples of File Transfer 116 and Hypertext Transfer 118. Any initiating client will have the Unique Identification and the Unique Identification of its recipient to the QSL Server 110 at which time the symmetric session keys will be generated. The QSL Server 110 will encrypt these symmetric keys with post-quantum algorithms used within the Hardware Security Module 108 and the relevant moving target information. Using the recipient clients symmetric key that was established during the Login Service 103 so only the recipient can decrypt that particular portion and then use the symmetric key the initiator established during the Login Service 103 it wishes to communicate with the initiator can decrypt and verifies it came from the Quantum Secure Layer Service 110 once this is completed all symmetric keys will be created and for communication.

Variable Length Buffer Handshake FIG. 1A 111 a, 111 b, 111 c, 111 d, 111 e to create a handshake for transferring a buffer of variable length to be used by all services involving a logged-in client, reliant only on Authenticated Encryption with Associated Data (AEAD). All buffers will be stored in RAM, and all parsing will occur in the C language. Each service will have custom functions to format and parse buffers exchanged using the QSL Variable Length Buffer Handshake 111 a. Summary to exchange any length buffer without knowledge of what size the buffer is going to be. It is sent over length followed by the buffer. To ensure the correct size the recipient has the correct size to read.

Variable Length Buffer Handshake Steps:

1. The initiator sends the length of buffer to the recipient using AEAD 2. The initiator sends the buffer to the recipient using AEAD

Login Service FIG. 1A 103 Client authentication, login module on the client would communicate with the login service 103 to authentication. Other components that are contain within this include but not limited to organization onboarding, administration onboarding, and individual clients. FIG. 1A and FIG. 1B represent 2 clients in an organization that communicate to the Server 100. This also implies multi-tenancy communication from client 120 a and 120 b to Server 100. An additional component within the Login Service 103 is the Registration Handshake 104 to identify the individual clients to the Server 100. This populates the unique identifier 122 FIG. 1C for the first time within the Server 100. The unique identifier elements and post-quantum token will be passed to the client. Other elements that are captured include items such as, IP address, MAC, routing address.

As part of the registration the client will need to perform the Forward Secrecy Handshake 106 a and that includes communication with the key encapsulation system of the Server 100 using but not limited to Saber, or Kyber Post Quantum algorithms. These associate a post quantum key pair structure the Server 100 retains the secret key portion of the pair structure. The Client 120 a, Client 120 b receives the public key portion and uses said key to establish a shared secret or symmetric key with Server 100. This process then creates a second post quantum key pair derived from the symmetric key and is communicated using the symmetric key to transmit in a protected manner thus reducing the probability of interception of the communication and data. This is unique to each session for data to be compromised the Server 100 secret key and the second symmetric key to get access to the data or session.

Device Authority Handshake FIG. 1A 105 is used when the Client 120 a, or 120 b need to log into the system. This is accomplished by using the unique identifier it uses the same Forward Secrecy Handshake 106 b to establish the client's authentication from the Unique Identifier Dataset 101 FIG. 1C using the post quantum token. The Server 100 and Device Authority Handshake 105 will update the symmetric key of Unique Identifier Dataset 101 FIG. 1C at login for the individual client unique identifiers. In some embodiments, the Registration Handshake and Device Authority Handshake can be configured to generate and share an ephemeral KEM public key with the client at their conclusion. In such an embodiment, the Forward Secrecy Handshake is not needed by the Device Authority Handshake—since the client initiates the handshake with an ephemeral KEM public key. This allows for a login with a reduced number of roundtrips.

Logout Service FIG. 1A 112 FIG. 1B 119 clears the dataset symmetric keys associated with the unique identifier at close of session. Logout 112 or 119 has access to Unique Identifier Dataset 101 associated FIG. 1C. The Logout Service offloads symmetric encryption/decryption to the HSM. The Logout Service pulls in the symmetric key(s) and routing address associated with relevant unique identifiers from Unique Identifier Dataset. The Logout Service may be activated by a lack of a response from the relevant client.

Authentication of clients and establishing a connection between crypto. KEM utilization which give a performance advantage and fewer resources and more efficient. Login, authentication, after established FS handshake.

Entropy Refill Service FIG. 1B 120 is used during high volume communications to replenish the clients 120 a or 120 b to continue the post-quantum secure communication or Data at Rest process. This data is requested from Quantum Secure Layer Service 110 and Key Management Service 113. The Entropy Refill Service offloads symmetric encryption/decryption to the HSM. The Entropy Refill Service provides bulk entropy from the QRNG to the client to maintain the Client's entropy pool, the advantage allows offline and high-volume key availability. The Entropy Refill Service pulls in the symmetric key(s) and routing address associated with relevant unique identifiers from Unique Identifier Dataset.

Key Management Service FIG. 1A 113 The KMS pulls in the symmetric key(s) and routing address associated with relevant unique identifiers from Unique Identifier Dataset.

Key Add Service FIG. 1A and FIG. 1B 114 a, 114 b Refresh the entropy pool with the addition of symmetric keys for and encrypted with HSM into the Server 100 database encryption keys system. This data is stored externally but cannot be access without the HSM to decrypt prior to transmittal. The Key Management Dataset FIG. 1D contains the information used in this process

Key Get Service FIG. 1A and FIG. 1B 115 a, 115 b reaches out to HSM to get keys get decrypted key from database.

Entropy Refill FIG. 1B 120 The Entropy Refill Service offloads symmetric encryption/decryption to the HSM. The Entropy Refill Service provides bulk entropy from the QRNG to the client to maintain the Client's entropy pool. The Entropy Refill Service pulls in the symmetric key(s) and routing address associated with relevant unique identifiers from Unique Identifier Dataset.

File Transfer FIG. 1B 116 File Transfer uses the QSL Handshake to receive session keys from the QSL Service for a secure connection with a peer. File Transfer then utilizes the functions provided by the QuSecure QSL Library (libqsl) for the QSL equivalent of the TLS Record Protocol. Symmetric encryption/decryption (AEAD) is offloaded to the S/HSM.

HyperText Transfer FIG. 1B 118 Hypertext Transfer uses the QSL Handshake to receive session keys from the QSL Service for a secure connection with a peer. Hypertext Transfer then utilizes the functions provided by the QuSecure QSL Library (libqsl) for the QSL equivalent of the TLS Record Protocol. Symmetric encryption/decryption (AEAD) is offloaded to the S/HSM.

Encrypt FIG. 1B 117 Encrypt (Data-At-Rest) utilizes Key Add to reach out to the Key Management Service, specifically the Key Add Service to get encryption keys. Encrypt encrypts the data using the Moving Target Design to switch between encryption keys. Symmetric encryption (AEAD) is offloaded to the S/HSM.

Key Add Service 114 b Refresh the entropy pool with the addition of symmetric keys for and encrypted with HSM into the Server 100 database encryption keys system. This data is stored externally but cannot be accessed without the HSM to decrypt prior to transmittal. The Key Management Dataset FIG. 1D contains the information used in this process

Decrypt FIG. 1B 118 Decrypt (Data-At-Rest) utilizes Key Get to reach out to the Key Management Service, specifically the Key Get Service to get decryption keys. Decrypt decrypts the data using the Moving Target Design to switch between decryption keys. Symmetric decryption (ADAD) is offloaded to the S/HSM.

Key Get reaches out to HSM to get keys get decrypted key from database.

Unique Identifier Dataset FIG. 1C 122, Unique Identifier Database and Key Management Database FIG. 1D 126 are configured with a static secret key (using a different KEM keypair than is shared with clients) and Services are configured with the corresponding static public key. At system start, the Forward Secrecy Handshake is performed between the Databases and the Services which access those databases—this is repeated periodically (after a number of bytes has been encrypted, for example) to maintain forward secrecy between Databases and Services during runtime. The Databases offload KEM keygen and decapsulation to the HSM, and the relevant Services offload encapsulation to the HSM. In some embodiments, the Registration Handshake and Device Authority Handshake can be configured to generate and share an ephemeral KEM public key with the client at their conclusion. In such an embodiment, the Forward Secrecy Handshake is not needed by the Device Authority Handshake—since the client initiates the handshake with an ephemeral KEM public key. This allows for a login with a reduced number of roundtrips. These structures are listed but not limited to the fields to achieve the described functionality for the preferred embodiment.

FIG. 2 is a block diagram of an example computer system 200 which can perform any one or more of the methods described herein, in accordance with one or more aspects of the present disclosure. In one example, the computer system 200 may include a computing device and correspond to one or more of the servers 100, the client 120 a, 120 b, or any suitable component of FIG. 1A. The computer system 200 may be connected (e.g., networked) to other computer systems in a local area network (LAN), an intranet, an extranet, or the Internet, including via the cloud or a peer-to-peer network. The computer system 200 may operate in the capacity of a server in a client-server network environment. The computer system 200 may be a personal computer (PC), a tablet computer, a wearable (e.g., wristband), a set-top box (STB), a personal Digital Assistant (PDA), a mobile phone, a smartphone, a camera, a video camera, an Internet of Things (IoT) device, or any device capable of executing a set of instructions (sequential or otherwise) that specify actions to be taken by that device. Further, while only a single computer system is illustrated, the term “computer” shall also be taken to include any collection of computers that individually or jointly execute a set (or multiple sets) of instructions to perform any one or more of the methods discussed herein.

The computer system 200 (one example of a “computing device”) illustrated in FIG. 2 includes a processing device 202, a main memory 204 (e.g., read-only memory (ROM), flash memory, solid state drives (SSDs), dynamic random access memory (DRAM) such as synchronous DRAM (SDRAM)), a static memory 206 (e.g., flash memory, solid state drives (SSDs), or static random access memory (SRAM)), and a memory device 208, wherein any of the foregoing may communicate with each other via a bus 210. In some implementations, the computer system 200 may further include a hardware security module (not shown).

The processing device 202 represents one or more general-purpose processing devices such as a microprocessor, central processing unit, or the like. More particularly, the processing device 202 may be a complex instruction set computing (CISC) microprocessor, reduced instruction set computing (RISC) microprocessor, very long instruction word (VLIW) microprocessor, or a processor implementing other instruction sets or processors implementing a combination of instruction sets. The processing device 202 may also be one or more special-purpose processing devices such as an application specific integrated circuit (ASIC), a system on a chip, a field programmable gate array (FPGA), a digital signal processor (DSP), network processor, or the like. The processing device 202 may be configured to execute instructions for performing any of the operations and steps discussed herein.

The computer system 200 illustrated in FIG. 4 further includes a network interface device 212. The computer system 200 also may include a video display 214 (e.g., a liquid crystal display (LCD), a light-emitting diode (LED), an organic light-emitting diode (OLED), a quantum LED, a cathode ray tube (CRT), a shadow mask CRT, an aperture grille CRT, or a monochrome CRT), one or more input devices 216 (e.g., a keyboard and/or a mouse or a gaming-like control), and one or more speakers 218 (e.g., a speaker). In one illustrative example, the video display 214 and the one or more input devices 216 may be combined into a single component or device (e.g., an LCD touchscreen).

The memory device 208 may include a computer-readable storage medium 202 on which the instructions 222 c embodying any one or more of the methods, operations, or functions described herein are stored. The instructions 222 c may also reside, completely or at least partially, within the main memory 204 as instructions 222 b and/or within the processing device 202 during execution thereof by the computer system 200. As such, the main memory 204 or as instruction 222 a and the processing device 202 also constitute computer-readable media. The instructions 222 may further be transmitted or received over a network via the network interface device 212.

While the computer-readable storage medium 220 is shown in the illustrative examples to be a single medium, the term “computer-readable storage medium” should be taken to include a single medium or multiple media (e.g., a centralized or distributed database, and/or associated caches and servers) that store the one or more sets of instructions. The term “computer-readable storage medium” shall also be taken to include any medium capable of storing, encoding or carrying out a set of instructions for execution by the machine and that cause the machine to perform any one or more of the methods disclosed herein. The term “computer-readable storage medium” shall accordingly be taken to include, but not be limited to, solid-state memories, optical media, and magnetic media.

While the computer system environment of 200 shows the basic components the addition of a Hardware Security Module 224 associated with a Quantum Random Number Generator 226 are added to complete the entropy required for Post Quantum computations and interactions. The use of these components is critical as described previously in the overall methods used for this system.

FIG. 3A Hash Then Encrypt AEAD 300 A method of Authenticated Encryption with Associated Data following the Hash-then-Encrypt framework. Associated data may be concatenated to the buffer and input to the cryptographic one-way hashing algorithm. The unencrypted associated data can then be concatenated with the initialization vector and encrypted buffer. The initialization vector determines the initial state of the symmetric encryption algorithm. Illustrates the sequence required to establish an Encrypted and Decrypted element. This method is 1 of 2 that will be presented as part of this systems use. At block 302, the input buffer that is in process will be presented to a one-way cryptographic hashing algorithm to begin the encryption process of this data. Block 304 generates the initialization vector that is used within the forward calculations. At Block 306 the elements listed are merged together with the protected symmetric key to create the encrypted payload. At Block 308 the said payload is then transmitted to the receiving client. Block 310-314 reverses the process with the same protected symmetric key and initialization vector for decrypting the data.

FIG. 3B Encrypt Then Hash AEAD 320 A method of Authenticated Encryption with Associated Data following the Encrypt-then-Hash framework. Associated data may be concatenated to the initialization vector and encrypted buffer before it is input to the universal hashing algorithm. The unencrypted associated data can then be concatenated with the initialization vector, encrypted buffer, and hash output. The initialization vector determines the initial state of the symmetric encryption algorithm. The sequence for this differs from FIG. 3A by generating the initialization vector 322. In block 324 the payload is encrypted using the first symmetric key and but not limited to AES-256 variants with the protected post quantum symmetric key (key1) and the initialization vector. Block 326 uses the second symmetric key (key 2) which creates the Hash of the now encrypted data thus creating a higher level of protection for transmission, but this is limited only symmetric key1 or symmetric key 2. The server generating a symmetric key can be updated by the server generating multiple symmetric keys and the server generating the maximum number of bytes each symmetric key may be used to encrypt; the clients switch to the next symmetric key prior to the current symmetric key encrypting the maximum number of bytes. Blocks 330-334 reverse the sequence to end with the data decrypted.

FIG. 4 Variable Length Buffer Handshake 400 The Variable Length Buffer Handshake is used to communicate a buffer of variable length between two parties. AEAD 402 is used to provide confidentiality and integrity of data. First the length of the buffer is sent by an initiator, then the buffer itself is sent by the initiator 404. The use of the FIG. 3B or FIG. 3A sequence with a variable length buffer to prevent overflow or underflow errors and attacks.

FIG. 5A One to One QSL Handshake 500 The one-to-one QSL Handshake provides an initiator with the necessary key material to establish a secure connection with one peer. The handshake may follow the Moving Target Design to switch between encryption keys. The initiator can forward the encrypted text from step 506 to the peer to initiate the secure connection. AEAD (Authenticated Encryption, Authenticated Decryption) Block 502 begins the initiation of a communication with a one to one or peer relationship. Block 504 requests and generates a session key that the one-to-one communications will use to begin the communication in this system this session key is a direct result of the Quantum Random Number Generator or a Quantum Value as the session key. This is shared between and use for the encryption as in block 508.

FIG. 5B One to Many QSL Handshake 510 The one-to-many QSL Handshake provides an initiator with the necessary key material to establish a secure connection with multiple peers. The handshake may follow the Moving Target Design to switch between encryption keys. The initiator can forward the encrypted texts from step 516 to each peer to initiate the secure connection. In block 512 this is the initiation of multiple recipients to one. Block 514 creates a Quantum Random Number Generated session key that is distributed to each of the recipients. Block 516 the server encrypts the initiators unique identifier with the other attributes listed. Block 518 once this process is complete another step-in encryption to the recipients is sent for the establishment of the connection.

FIG. 6A Single Key Exchange 600 The exchange of a single shared secret using a Key Encapsulation Mechanism. The initiator encapsulates the shared secret using a public key, creating a ciphertext. The recipient decapsulates the ciphertext to produce the shared secret using a secret key. Block 602 initiates the single key and shared secret this invokes block 604 to send the ciphertext to server. Block 606 a Post Quantum key pair is created and used to transmit the ciphertext and Quantum Session key.

FIG. 6B Double Key Exchange 610 The exchange of a multiple shared secrets using a Key Encapsulation Mechanism. The initiator encapsulates the two shared secrets using a public key, creating a two ciphertexts. The recipient decapsulates the two ciphertext to produce two shared secrets using a secret key. Blocks 612-620 allow for double the key exchange as from FIG. 6A.

FIG. 6C Forward Secrecy Handshake 630 The Forward Secrecy Handshake allows two parties to establish forward secrecy using Key Encapsulation Mechanisms. The first shared secret is exchanged using a static KEM keypair. The shared secret is then used to exchange an ephemeral KEM keypair, which is used to establish a second shared secret. The second shared secret is not vulnerable if the long-term secret, the static KEM key pair, is compromised. Block 632-648 show a sequence of establishing proper secrecy novel and highly protective.

FIG. 7 Registration 700 A method for client registration. The server generates a unique identifier and post-quantum password for the client and sends this information to the client using AEAD. This exchange occurs after the Forward Secrecy Handshake has been performed. Block 702-706 using the previous sequences establishes the client registration as valid per unique identifier. Namely, the server generates unique identifier of initiator 702, then the server generates password for initiator 704 and finally, the server sends the unique identifier concatenated with the password to the initiator using AEAD with the shared secret stored for initiator 706.

FIG. 8 Moving Target 800 The Moving Target Design provides a method for injecting new key material into an existing session, as well as a method to switch between encryption keys. The keys and the number of bytes each key will encrypt is determined by the server and is transferred to the client using the Variable Length Buffer Handshake. This process 800 starts by having the initiator uses AEAD to send the number of bytes in the plan to encrypt to the server 802. Then the server randomly generates the number of keys to be used, each key, and the number of bytes each key will encrypt 804. The server then uses the variable length buffer handshake to send each key and the number of bytes each key will encrypt to the initiator 806. The process then determines if the initiator runs of keys before all of data is encrypted, initiator restart from the beginning, 808.

FIG. 9 Device Authority 900 A method for client login. The client sends their unique identifier and post-quantum password to the server for verification using AEAD. 

What is claimed:
 1. A method comprising: providing zero-trust, forward secrecy, confidentiality of data, and integrity of data comprising a client encapsulating a first symmetric key using a static Key Encapsulation Mechanism (KEM) public key to produce a ciphertext; the client sending the ciphertext to a server; the client generating an ephemeral KEM keypair; the client sending the ephemeral KEM public key to the server using an Authenticated Encryption with Associated Data (AEAD) with the first symmetric key; the server decapsulating the ciphertext using the static KEM private key to produce the first symmetric key; the server encapsulating a second symmetric key using the ephemeral KEM public key to produce another ciphertext; the server sending the other ciphertext to the client; the client decapsulating the other ciphertext using the ephemeral KEM public key to produce the second symmetric key.
 2. The method of claim 1, wherein performing mutual identity authentication; the method further comprising: the server generating the unique identifier of the client; the server generating a password for the client; the server sending the unique identifier and password to the client using AEAD with the second symmetric key.
 3. The method of claim 2, further comprising: the server generating an ephemeral KEM keypair; the server sending the ephemeral KEM public key to the client using AEAD with the second symmetric key.
 4. The method of claim 2, wherein the password comprises a post-quantum level of security, and wherein the server generates the password with a random number generator.
 5. The method of claim 1 wherein performing mutual identity authentication; the method further comprising: the client sending their unique identifier and password to the server using AEAD with the second symmetric key.
 6. The method of claim 5, further comprising: the server generating an ephemeral KEM keypair; the server sending the ephemeral KEM public key to the client using AEAD with the second symmetric key.
 7. The method of claim 6, wherein using an ephemeral KEM keypair to provide zero-trust and forward secrecy, the method further comprising: the client encapsulating a symmetric key using the ephemeral KEM public key to produce a ciphertext; the client sending the ciphertext to the server; the server decapsulating the ciphertext using the ephemeral KEM private key to produce a symmetric key.
 8. A method to: provide direct communication between a server and an initiator client, indirect communication between the server and a recipient client, and direct communication between the initiator client and the recipient client; and provide mutual identity authentication, wherein the method comprises: providing zero-trust, forward secrecy, confidentiality of data, and integrity of data comprising the client encapsulating a first symmetric key using a static Key Encapsulation Mechanism (KEM) public key to produce a ciphertext; the initiator client sending the ciphertext to the server; the initiator client generating an ephemeral KEM keypair; the initiator client sending the ephemeral KEM public key to the server using an Authenticated Encryption with Associated Data (AEAD) with the first symmetric key; the server decapsulating the ciphertext using the static KEM private key to produce the first symmetric key; the server encapsulating a second symmetric key using the ephemeral KEM public key to produce a ciphertext; the server sending the ciphertext to the recipient client; and the recipient client decapsulating the ciphertext using the ephemeral KEM private key to produce the second symmetric key.
 9. The method of claim 8, further comprising: the initiator client sending the unique identifier of the recipient client to the server using AEAD with a symmetric key shared with the server; the server generating a symmetric key; the server encrypting the unique identifier of the initiator client, the routing address of the initiator client, and the generated symmetric key using AEAD with a symmetric key shared with the recipient client to produce an encrypted buffer; the server sending the routing address of the recipient client, the generated symmetric key, and the encrypted buffer to the initiator client using AEAD with a symmetric key shared with the initiator client; the initiator client forwarding the encrypted buffer to the recipient client to establish a secure session.
 10. The method of claim 8, wherein there is indirect communication between the server and multiple recipient clients and there is direct communication between the initiator client and multiple recipient clients.
 11. The method of claim 10 further comprising: the initiator client sending the unique identifier of each recipient client to the server using AEAD with a symmetric key shared with the server; the server generating a symmetric key for each recipient client; for each recipient client, the server encrypting the unique identifier of the initiator client, the routing address of the initiator client, and the generated symmetric key using AEAD with a symmetric key shared with the recipient client to produce an encrypted buffer; for each recipient client, the server sending the routing address of the recipient client, the generated symmetric key, and the encrypted buffer using AEAD with a symmetric key shared with the initiator client; the initiator client forwarding the encrypted buffer to each recipient client to establish a secure session.
 12. The method of claim 8, wherein there is direct communication between the server and the recipient client.
 13. The method of claim 12, further comprising: the initiator client sending the unique identifier of the recipient client to the server using AEAD with a symmetric key shared with the server; the server generating a symmetric key; the server sending the unique identifier of the initiator client, the routing address of the initiator client, and the generated symmetric key to the recipient client using AEAD with a symmetric key shared with the recipient client; the server sending the routing address of the recipient client and the generated symmetric key to the initiator client using AEAD with a symmetric key shared with the initiator client; the initiator client establishing a secure session with the recipient client.
 14. The method of claim 13, wherein the server sending the routing address of the recipient client and the generated symmetric key to the initiator client using AEAD with a symmetric key shared with the initiator client; the server sending the unique identifier of the initiator client, the routing address of the initiator client, and the generated symmetric key to the recipient client using AEAD with a symmetric key shared with the recipient client.
 15. The method of claim 8, wherein there is direct communication between the server and multiple recipient clients and there is direct communication between the initiator client and multiple recipient clients.
 16. The method of claim 15, further comprising: the initiator client sending the unique identifier of each recipient client to the server using AEAD with a symmetric key shared with the server; the server generating a symmetric key for each recipient client; for each recipient client, the server sending the unique identifier of the initiator client, the routing address of the initiator client, and the generated symmetric key to the recipient client using AEAD with a symmetric key shared with the recipient client; for each recipient client, the server sending the routing address of the recipient client, the generated symmetric key, and the encrypted buffer using AEAD with a symmetric key shared with the initiator client; the initiator client establishing a secure session with each recipient client.
 17. The method of claim 16, wherein for each recipient client, the server sending the routing address of the recipient client, the generated symmetric key, and the encrypted buffer using AEAD with a symmetric key shared with the initiator client; for each recipient client, the server sending the unique identifier of the initiator client, the routing address of the initiator client, and the generated symmetric key to the recipient client using AEAD with a symmetric key shared with the recipient client.
 18. The method of claim 9, wherein the server generating the maximum number of bytes the symmetric key may be used to encrypt, and the symmetric key is a first symmetric key; wherein the method further comprises: generating, by the server, a second symmetric key and the maximum number of bytes the second symmetric key may be used to encrypt; the initiator client requests the second symmetric key from the server prior to the first symmetric key encrypting the maximum number of bytes.
 19. The method of claim 11, wherein the server generating the maximum number of bytes the symmetric key may be used to encrypt, and the symmetric key is a first symmetric key; wherein the method further comprises: generating, by the server, a second symmetric key and the maximum number of bytes the second symmetric key may be used to encrypt; the initiator client requests the second symmetric key from the server prior to the first symmetric key encrypting the maximum number of bytes.
 20. The method of claim 11, wherein for each recipient client, the server generating the maximum number of bytes the symmetric key may be used to encrypt, and the symmetric key is a first symmetric key; wherein the method further comprises: for each recipient client, the server generating a second symmetric key and the maximum number of bytes the second symmetric key may be used to encrypt; the initiator client requests the second symmetric key from the server prior to the first symmetric key encrypting the maximum number of bytes.
 21. The method of claim 16, wherein for each recipient client, the server generating the maximum number of bytes the symmetric key may be used to encrypt, and the symmetric key is a first symmetric key; wherein the method further comprises: for each recipient client, the server generating a second symmetric key and the maximum number of bytes the second symmetric key may be used to encrypt; the initiator client requests the second symmetric key from the server prior to the first symmetric key encrypting the maximum number of bytes.
 22. The method of claim 16 wherein the server generating a symmetric key is updated by the server generating multiple symmetric keys and the server generating the maximum number of bytes each one of the symmetric key may be used to encrypt; and the clients switch to a next symmetric key prior to a current symmetric key encrypting the maximum number of bytes.
 23. The method of claim 11 wherein the server generating a symmetric key is updated by the server generating multiple symmetric keys and the server generating the maximum number of bytes each symmetric key may be used to encrypt; the clients switch to the next symmetric key prior to a current symmetric key encrypting the maximum number of bytes.
 24. The method of claim 13 wherein the server generating a symmetric key is updated by the server generating multiple symmetric keys and the server generating the maximum number of bytes each symmetric key may be used to encrypt; the clients switch to the next symmetric key prior to a current symmetric key encrypting the maximum number of bytes.
 25. The method of claim 14 wherein the server generating a symmetric key is updated by the server generating multiple symmetric keys and the server generating the maximum number of bytes each symmetric key may be used to encrypt; the clients switch to the next symmetric key prior to a current symmetric key encrypting the maximum number of bytes.
 26. The method of claim 16 wherein the server generating a symmetric key is updated by the server generating multiple symmetric keys and the server generating the maximum number of bytes each symmetric key may be used to encrypt; the clients switch to the next symmetric key prior to a current symmetric key encrypting the maximum number of bytes.
 27. The method of claim 17 wherein the providing of the second generated symmetric key from the server to the initiator client is performed after a server-generated period of time following the providing of the first session key to the initiator client.
 28. The method of claim 18 wherein the providing of the second generated symmetric key from the server to the initiator client is performed after a server-generated period of time following the providing of the first session key to the initiator client.
 29. The method of claim 18 wherein the server generating a symmetric key is updated by the server generating multiple symmetric keys and the server generating the maximum number of bytes each symmetric key may be used to encrypt; the clients switch to the next symmetric key prior to a current symmetric key encrypting the maximum number of bytes; the initiator client requests the second set of symmetric keys from the server prior to all of the first set of symmetric keys encrypting the maximum number of bytes.
 30. The method of claim 19 wherein the server generating a symmetric key is updated by the server generating multiple symmetric keys and the server generating the maximum number of bytes each symmetric key may be used to encrypt; the clients switch to the next symmetric key prior to a current symmetric key encrypting the maximum number of bytes; the initiator client requests the second set of symmetric keys from the server prior to all of the first set of symmetric keys encrypting the maximum number of bytes.
 31. The method of claim 19 wherein the providing of the second generated symmetric key(s) from the server to the initiator client is performed after a server-generated period of time following the providing of the first session key to the initiator client.
 32. The method of claim 20 wherein the providing of the second generated symmetric key(s) from the server to the initiator client is performed after a server-generated period of time following the providing of the first session key to the initiator client.
 33. The method of claim 21 wherein the providing of the second generated symmetric key(s) from the server to the initiator client is performed after a server-generated period of time following the providing of the first session key to the initiator client.
 34. The method of claim 9 wherein the symmetric key comprises a post-quantum level of security, and wherein the server generates the symmetric key with a random number generator.
 35. The method of claim 11 wherein the symmetric key comprises a post-quantum level of security, and wherein the server generates the symmetric key with a random number generator.
 36. The method of claim 13 wherein the symmetric key comprises a post-quantum level of security, and wherein the server generates the symmetric key with a random number generator.
 37. The method of claim 14 wherein the symmetric key comprises a post-quantum level of security, and wherein the server generates the symmetric key with a random number generator.
 38. The method of claim 16 wherein the symmetric key comprises a post-quantum level of security, and wherein the server generates the symmetric key with a random number generator.
 39. The method of claim 17 wherein the symmetric key comprises a post-quantum level of security, and wherein the server generates the symmetric key with a random number generator.
 40. The method of claim 18 wherein the symmetric key comprises a post-quantum level of security, and wherein the server generates the symmetric key with a random number generator.
 41. The method of claim 19 wherein the symmetric key comprises a post-quantum level of security, and wherein the server generates the symmetric key with a random number generator.
 42. The method of claim 20 wherein the symmetric key comprises a post-quantum level of security, and wherein the server generates the symmetric key with a random number generator.
 43. The method of claim 21 wherein the symmetric key comprises a post-quantum level of security, and wherein the server generates the symmetric key with a random number generator.
 44. A method to provide a client communicate with a server, specifically a key management service, in order to obtain encryption/decryption keys for data-at-rest, wherein the method comprises: providing zero-trust, forward secrecy, confidentiality of data, and integrity of data comprising a client encapsulating a first symmetric key using a static Key Encapsulation Mechanism (KEM) public key to produce a ciphertext; the client sending the ciphertext to the server; the client generating an ephemeral KEM keypair; the client sending the ephemeral KEM public key to the server using Authenticated Encryption with Associated Data (AEAD) with the first symmetric key; the server decapsulating the ciphertext using the static KEM private key to produce the first symmetric key; the server encapsulating a second symmetric key using the ephemeral KEM public key to produce a ciphertext; the server sending the ciphertext to the client; the client decapsulating the ciphertext using the ephemeral KEM secret key to produce the second symmetric key.
 45. The method of claim 44 further comprising: the client requesting an encryption key; the server generating a symmetric key and a handle for the symmetric key; the server sending the symmetric key and the handle to the client using AEAD with a symmetric key shared with the client; the client encrypting data-at-rest using AEAD with the symmetric key.
 46. The method of claim 44 further comprising: the client sending the handle to the server using AEAD with a symmetric key shared with the server; the server sending the symmetric key to the client using AEAD with a symmetric key shared with the client; the client decrypting data-at-rest using AEAD with the symmetric key.
 47. The method of claim 45 wherein the client sending the number of bytes that will be encrypted to the server using AEAD with a symmetric key shared with the server; the server generating a symmetric key is replaced by the server generating multiple symmetric keys and the server generating the maximum number of bytes each symmetric key may be used to encrypt; the client switches to the next symmetric key prior to a current symmetric key encrypting the maximum number of bytes.
 48. The method of claim 46 wherein the server generating a symmetric key is updated by the server generating multiple symmetric keys and the server generating the maximum number of bytes each symmetric key may be used to encrypt; the client switches to the next symmetric key prior to a current symmetric key encrypting the maximum number of bytes.
 49. The method of claim 44, further comprising: a client communicating with the server, specifically the entropy refill service, in order to obtain a number of bytes with high entropy.
 50. The method of claim 49, further comprising: the client sending the number of bytes of entropy requested to the server using AEAD with a symmetric key shared with the server; the server generating the number of bytes of entropy that was requested; the server sending the bytes of entropy to the client using AEAD with a symmetric key shared with the client.
 51. A server computer system for handshaking to provide at least post-quantum and classical communication security over digital or analog transmissions, the server computer system comprising a memory and at least one processor coupled to the memory, wherein: the server computer system is configured to provide zero-trust, forward secrecy, confidentiality of data, and integrity of data; a client computing device is configured to: encapsulate a first symmetric key using a static KEM public key to produce a ciphertext; send the ciphertext to the server computer system; generate an ephemeral KEM keypair; send the ephemeral KEM public key to the server computer system using AEAD with the first symmetric key; the at least one processor of the server computer system is configured to execute instructions to: decapsulate the ciphertext using the static KEM private key to produce the first symmetric key; encapsulate a second symmetric key using the ephemeral KEM public key to produce a ciphertext; send the ciphertext to the client computing device; and the client computing device is further configured to decapsulate the ciphertext using the ephemeral KEM secret key to produce the second symmetric key.
 52. The server computer system of claim 51, further configured to perform mutual identity authentication, and wherein the at least one processor of the server computer system is further configured to execute instructions to: generate the unique identifier of the client computing device; generate a password for the client computing device; and send the unique identifier and password to the client computing device using AEAD with the second symmetric key.
 53. The server computer system of claim 52, wherein the at least one processor of the server computer system is further configured to execute instructions to: generate an ephemeral KEM keypair; and send the ephemeral KEM public key to the client computing device using AEAD with the second symmetric key.
 54. The server computer system of claim 52, wherein the password comprises a post-quantum level of security, and wherein the at least one processor of the server computer system is further configured to execute instructions to generate the password with a random number generator.
 55. The server computer system of claim 51, further configured to perform mutual identity authentication, and wherein the client computing device is further configured to send its unique identifier and password to the server computer system using AEAD with the second symmetric key.
 56. The server computer system of claim 55, wherein the at least one processor of the server computer system is further configured to execute instructions to: generate an ephemeral KEM keypair; and send the ephemeral KEM public key to the client computing device using AEAD with the second symmetric key.
 57. The server computer system of claim 56, further configured to use an ephemeral KEM keypair to provide zero-trust and forward secrecy, and wherein: the client computing device is further configured to: encapsulate a symmetric key using the ephemeral KEM public key to produce a ciphertext; and send the ciphertext to the server computer system; and the at least one processor of the server computer system is further configured to execute instructions to decapsulate the ciphertext using the ephemeral KEM private key to produce a symmetric key.
 58. A server computer system comprising a memory and at least one processor coupled to the memory, wherein: the server computer system is configured to: provide direct communication between the server computer system and an initiator client, provide indirect communication between the server computer system and a recipient client, and facilitate direct communication between the initiator client and the recipient client; provide mutual identity authentication; and provide zero-trust, forward secrecy, confidentiality of data, and integrity of data; the initiator client is configured to: encapsulate the first symmetric key using the static KEM public key to produce a ciphertext; send the ciphertext to the server computer system; generate an ephemeral KEM keypair; send the ephemeral KEM public key to the server computer system using AEAD with the first symmetric key; the at least one processor of the server computer system is configured to execute instructions to: decapsulate the ciphertext using the static KEM private key to produce the first symmetric key; encapsulate a second symmetric key using the ephemeral KEM public key to produce a ciphertext; and send the ciphertext to the client; and the client is further configured to decapsulate the ciphertext using the ephemeral KEM secret key to produce the second symmetric key.
 59. The server computer system of claim 58, wherein: the initiator client is configured to send the unique identifier of the recipient client to the server computer system using AEAD with a symmetric key shared with the server computer system; the at least one processor of the server computer system is further configured to execute instructions to generate a symmetric key; the at least one processor of the server computer system is further configured to execute instructions to encrypt the unique identifier of the initiator client, the routing address of the initiator client, and the generated symmetric key using AEAD with a symmetric key shared with the recipient client to produce an encrypted buffer; the at least one processor of the server computer system is further configured to execute instructions to send the routing address of the recipient client, the generated symmetric key, and the encrypted buffer to the initiator client using AEAD with a symmetric key shared with the initiator client; and the initiator client is further configured to forward the encrypted buffer to the recipient client to establish a secure session.
 60. The server computer system of claim 58, wherein there is indirect communication between the server computer system and multiple recipient clients and there is direct communication between the initiator client and multiple recipient clients.
 61. The server computer system of claim 60, wherein: the initiator client is configured to send the unique identifier of each recipient client to the server computer system using AEAD with a symmetric key shared with the server computer system; the at least one processor of the server computer system is further configured to execute instructions to: generate a symmetric key for each recipient client; for each recipient client, encrypt the unique identifier of the initiator client, the routing address of the initiator client, and the generated symmetric key using AEAD with a symmetric key shared with the recipient client to produce an encrypted buffer; and for each recipient client, send the routing address of the recipient client, the generated symmetric key, and the encrypted buffer using AEAD with a symmetric key shared with the initiator client; and the initiator client is further configured to forward the encrypted buffer to each recipient client to establish a secure session.
 62. The server computer system of claim 58, wherein there is direct communication between the server computer system and a recipient client.
 63. The server computer system of claim 62, wherein: the initiator client is further configured to send the unique identifier of the recipient client to the server computer system using AEAD with a symmetric key shared with the server computer system; the at least one processor of the server computer system is further configured to execute instructions to: generate a symmetric key; send the unique identifier of the initiator client, the routing address of the initiator client, and the generated symmetric key to the recipient client using AEAD with a symmetric key shared with the recipient client; and send the routing address of the recipient client and the generated symmetric key to the initiator client using AEAD with a symmetric key shared with the initiator client; and the initiator client is further configured to establish a secure session with the recipient client.
 64. The server computer system of claim 63, wherein the at least one processor of the server computer system is further configured to execute instructions to: send the routing address of the recipient client and the generated symmetric key to the initiator client using AEAD with a symmetric key shared with the initiator client; and send the unique identifier of the initiator client, the routing address of the initiator client, and the generated symmetric key to the recipient client using AEAD with a symmetric key shared with the recipient client.
 65. The server computer system of claim 58, wherein there is direct communication between the server computer system and multiple recipient clients and there is direct communication between the initiator client and multiple recipient clients.
 66. The server computer system of claim 65, wherein: the initiator client is further configured to send the unique identifier of each recipient client to the server computer system using AEAD with a symmetric key shared with the server computer system; the at least one processor of the server computer system is further configured to execute instructions to: generate a symmetric key for each recipient client; for each recipient client, send the unique identifier of the initiator client, the routing address of the initiator client, and the generated symmetric key to the recipient client using AEAD with a symmetric key shared with the recipient client; for each recipient client, send the routing address of the recipient client, the generated symmetric key, and the encrypted buffer using AEAD with a symmetric key shared with the initiator client; and the initiator client is further configured to establish a secure session with each recipient client.
 67. The server computer system of claim 66, wherein for each recipient client, the at least one processor of the server computer system is further configured to execute instructions to: send the routing address of the recipient client, the generated symmetric key, and the encrypted buffer using AEAD with a symmetric key shared with the initiator client; and send the unique identifier of the initiator client, the routing address of the initiator client, and the generated symmetric key to the recipient client using AEAD with a symmetric key shared with the recipient client.
 68. The server computer system of claim 59, wherein: the at least one processor of the server computer system is further configured to execute instructions to: generate a maximum number of bytes the symmetric key may be used to encrypt, wherein the symmetric key is a first symmetric key; and generate a second symmetric key and a maximum number of bytes the second symmetric key may be used to encrypt; and the initiator client is further configured to request the second symmetric key from the server computer system prior to the first symmetric key encrypting the maximum number of bytes.
 69. The server computer system of claim 61, wherein the at least one processor of the server computer system is further configured to execute instructions to: generate a maximum number of bytes the symmetric key may be used to encrypt, and the symmetric key is a first symmetric key; generate a second symmetric key and a maximum number of bytes the second symmetric key may be used to encrypt; the initiator client is further configured to request the second symmetric key from the server computer system prior to the first symmetric key encrypting the maximum number of bytes.
 70. The server computer system of claim 61, wherein: for each recipient client, the at least one processor of the server computer system is further configured to execute instructions to: generate a maximum number of bytes the symmetric key may be used to encrypt, wherein the symmetric key is a first symmetric key; generate a second symmetric key and a maximum number of bytes the second symmetric key may be used to encrypt; the initiator client is further configured to request the second symmetric key from the server computer system prior to the first symmetric key encrypting the maximum number of bytes.
 71. The server computer system of claim 66, wherein: for each recipient client, the at least one processor of the server computer system is further configured to execute instructions to: generate a maximum number of bytes the symmetric key may be used to encrypt, wherein the symmetric key is a first symmetric key; and generate a second symmetric key and a maximum number of bytes the second symmetric key may be used to encrypt; the initiator client is further configured to request the second symmetric key from the server computer system prior to the first symmetric key encrypting the maximum number of bytes.
 72. The server computer system of claim 66, wherein: the server computer system generating the symmetric key is updated by the server computer system generating multiple symmetric keys and the server computer system generating the maximum number of bytes each symmetric key may be used to encrypt; and the clients are further configured to switch to the next symmetric key prior to a current symmetric key encrypting the maximum number of bytes.
 73. The server computer system of claim 61, wherein: the server computer system generating a symmetric key is updated by the server computer system generating multiple symmetric keys and the server computer system generating the maximum number of bytes each symmetric key may be used to encrypt; and the clients are further configured to switch to the next symmetric key prior to a current symmetric key encrypting the maximum number of bytes.
 74. The server computer system of claim 63, wherein: the server computer system generating a symmetric key is updated by the server computer system generating multiple symmetric keys and the server computer system generating the maximum number of bytes each symmetric key may be used to encrypt; and the clients are further configured to switch to the next symmetric key prior to a current symmetric key encrypting the maximum number of bytes.
 75. The server computer system of claim 64, wherein: the server computer system generating a symmetric key is updated by the server computer system generating multiple symmetric keys and the server computer system generating the maximum number of bytes each symmetric key may be used to encrypt; and the clients are further configured to switch to the next symmetric key prior to a current symmetric key encrypting the maximum number of bytes.
 76. The server computer system of claim 66, wherein: the server computer system generating a symmetric key is updated by the server computer system generating multiple symmetric keys and the server computer system generating the maximum number of bytes each symmetric key may be used to encrypt; and the clients are further configured to switch to the next symmetric key prior to a current symmetric key encrypting the maximum number of bytes.
 77. The server computer system of claim 67, wherein the providing of the second generated symmetric key(s) from the server computer system to the initiator client is performed after a server-generated period of time following the providing of the first session key to the initiator client.
 78. The server computer system of claim 68, wherein the providing of the second generated symmetric key(s) from the server computer system to the initiator client is performed after a server-generated period of time following the providing of the first session key to the initiator client.
 79. The server computer system of claim 68, wherein the server computer system generating a symmetric key is updated by the server computer system generating multiple symmetric keys and the server computer system generating the maximum number of bytes each symmetric key may be used to encrypt; the clients are further configured to switch to the next symmetric key prior to a current symmetric key encrypting the maximum number of bytes; and the initiator client is further configured to request the second set of symmetric keys from the server computer system prior to all of the first set of symmetric keys encrypting the maximum number of bytes.
 80. The server computer system of claim 69, wherein: the server computer system generating a symmetric key is updated by the server computer system generating multiple symmetric keys and the server computer system generating the maximum number of bytes each symmetric key may be used to encrypt; the clients are further configured to switch to the next symmetric key prior to a current symmetric key encrypting the maximum number of bytes; the initiator client is further configured to request the second set of symmetric keys from the server prior to all of the first set of symmetric keys encrypting the maximum number of bytes.
 81. The server computer system of claim 69, wherein the providing of the second generated symmetric key(s) from the server computer system to the initiator client is performed after a server-generated period of time following the providing of the first session key to the initiator client.
 82. The server computer system of claim 70, wherein the providing of the second generated symmetric key(s) from the server computer system to the initiator client is performed after a server-generated period of time following the providing of the first session key to the initiator client.
 83. The server computer system of claim 71, wherein the providing of the second generated symmetric key(s) from the server computer system to the initiator client is performed after a server-generated period of time following the providing of the first session key to the initiator client.
 84. The server computer system of claim 59, wherein the symmetric key comprises a post-quantum level of security, and wherein the at least one processor of the server computer system is further configured to execute instructions to generate the symmetric key with a random number generator.
 85. The server computer system of claim 61, wherein the symmetric key comprises a post-quantum level of security, and wherein the at least one processor of the server computer system is further configured to execute instructions to generate the symmetric key with a random number generator.
 86. The server computer system of claim 63, wherein the symmetric key comprises a post-quantum level of security, and wherein the at least one processor of the server computer system is further configured to execute instructions to generate the symmetric key with a random number generator.
 87. The server computer system of claim 64, wherein the symmetric key comprises a post-quantum level of security, and wherein the at least one processor of the server computer system is further configured to execute instructions to generate the symmetric key with a random number generator.
 88. The server computer system of claim 66, wherein the symmetric key comprises a post-quantum level of security, and wherein the at least one processor of the server computer system is further configured to execute instructions to generate the symmetric key with a random number generator.
 89. The server computer system of claim 67, wherein the symmetric key comprises a post-quantum level of security, and wherein the at least one processor of the server computer system is further configured to execute instructions to generate the symmetric key with a random number generator.
 90. The server computer system of claim 68, wherein the symmetric key comprises a post-quantum level of security, and wherein the at least one processor of the server computer system is further configured to execute instructions to generate the symmetric key with a random number generator.
 91. The server computer system of claim 69, wherein the symmetric key comprises a post-quantum level of security, and wherein the at least one processor of the server computer system is further configured to execute instructions to generate the symmetric key with a random number generator.
 92. The server computer system of claim 70, wherein the symmetric key comprises a post-quantum level of security, and wherein the at least one processor of the server computer system is further configured to execute instructions to generate the symmetric key with a random number generator.
 93. The server computer system of claim 71, wherein the symmetric key comprises a post-quantum level of security, and wherein the at least one processor of the server computer system is further configured to execute instructions to generate the symmetric key with a random number generator.
 94. A server computer system comprising a memory and at least one processor coupled to the memory, wherein: the server computer system is configured to: provide communication for a client computing device with the server computer system, specifically a key management service, in order to obtain encryption/decryption keys for data-at-rest; and provide zero-trust, forward secrecy, confidentiality of data, and integrity of data comprising the client computing device; the client computing device is configured to: encapsulate the first symmetric key using the static KEM public key to produce a ciphertext; send the ciphertext to the server computer system; generate an ephemeral KEM keypair; and send the ephemeral KEM public key to the server computer system using AEAD with the first symmetric key; the at least one processor of the server computer system is configured to execute instructions to: decapsulate the ciphertext using the static KEM private key to produce the first symmetric key; encapsulate a second symmetric key using the ephemeral KEM public key to produce a ciphertext; and send the ciphertext to the client computing device; and the client computing device is further configured to decapsulate the ciphertext using the ephemeral KEM secret key to produce the second symmetric key.
 95. The server computer system of claim 94, wherein: the client computing device is further configured to request an encryption key; the at least one processor of the server computer system is further configured to execute instructions to: generate a symmetric key and a handle for the symmetric key; and send the symmetric key and the handle to the client computing device using AEAD with a symmetric key shared with the client computing device; and the client computing device is further configured to encrypt data-at-rest using AEAD with the symmetric key.
 96. The server computer system of claim 94, wherein: the client computing device is further configured to send the handle to the server computer system using AEAD with a symmetric key shared with the server computer system; the at least one processor of the server computer system is further configured to execute instructions to send the symmetric key to the client computing device using AEAD with a symmetric key shared with the client computing device; the client computing device is further configured to decrypt data-at-rest using AEAD with the symmetric key.
 97. The server computer system of claim 95, wherein: the client computing device is further configured to send a number of bytes that will be encrypted to the server computer system using AEAD with a symmetric key shared with the server computer system; the server computer system generating a symmetric key is updated by the server computer system generating multiple symmetric keys and the server computer system generating a maximum number of bytes each symmetric key may be used to encrypt; and the client computing device is further configured to switch to the next symmetric key prior to a current symmetric key encrypting the maximum number of bytes.
 98. The server computer system of claim 96, wherein: the server computer system generating a symmetric key is updated by the server computer system generating multiple symmetric keys and the server generating the maximum number of bytes each symmetric key may be used to encrypt; the client computing device is further configured to switch to the next symmetric key prior to a current symmetric key encrypting the maximum number of bytes.
 99. The server computer system of claim 94, wherein the client computing device is further configured to communicate with the server computer system, specifically the entropy refill service, in order to obtain a number of bytes with high entropy.
 100. The server computer system of claim 99, wherein the client computing device is further configured to send the number of bytes of entropy requested to the server computer system using AEAD with a symmetric key shared with the server computer system; and the at least one processor of the server computer system is further configured to execute instructions to: generate the requested number of bytes of entropy; and send the bytes of entropy to the client computing device using AEAD with a symmetric key shared with the client computing device. 